package io.esirong.util;

import android.text.TextUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringUtils {


    /**
     * 使用指定符号连接List集合中的字符串
     *
     * @param items
     * @param joinSign 指定连接符
     * @return 字符串
     * @see String#join(CharSequence, Iterable)
     */
    public static <E> String joinStringItem(List<E> items, String joinSign) {
        StringBuilder joinedItems = new StringBuilder();
        if (items != null) {
            for (E p : items) {
                joinedItems.append(joinSign).append(p);
            }
            if (joinedItems.toString().startsWith(joinSign)) {
                joinedItems = new StringBuilder(joinedItems.substring(1));
            }
        }
        return joinedItems.toString();
    }

    /**
     * 根据文件路径解析文件名
     *
     * @param filePath 文件名路径
     * @return 文件名
     */
    public static String parseFileName(String filePath) {
        String fileName = filePath;
        if (!TextUtils.isEmpty(filePath)) {
            filePath = filePath.replaceAll("\\\\", "/");
            String[] parts = filePath.split("/");
            if (parts != null && parts.length > 0) {
                fileName = parts[parts.length - 1];
            }
        }
        return fileName;
    }

    /**
     * 过滤HTML标签的方法，正则表达式修改 斜杠不用再转义
     */
    public static String delHTMLTag(String htmlStr) {
        if (htmlStr == null || "null".equals(htmlStr)) {
            return "";
        }
//		String regEx_script = "<script[^>]*?>[\\s\\S]*?<\\/script>"; // 定义script的正则表达式
//		String regEx_style = "<style[^>]*?>[\\s\\S]*?<\\/style>"; // 定义style的正则表达式
        String regEx_script = "<script[^>]*?>[\\s\\S]*?</script>"; // 定义script的正则表达式
        String regEx_style = "<style[^>]*?>[\\s\\S]*?</style>"; // 定义style的正则表达式
        String regEx_html = "<[^>]+>"; // 定义HTML标签的正则表达式
        Pattern p_script = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE);
        Matcher m_script = p_script.matcher(htmlStr);
        htmlStr = m_script.replaceAll(""); // 过滤script标签
        Pattern p_style = Pattern.compile(regEx_style, Pattern.CASE_INSENSITIVE);
        Matcher m_style = p_style.matcher(htmlStr);
        htmlStr = m_style.replaceAll(""); // 过滤style标签
        Pattern p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);
        Matcher m_html = p_html.matcher(htmlStr);
        htmlStr = m_html.replaceAll(""); // 过滤html标签
        return htmlStr.trim(); // 返回文本字符串
    }

    /**
     * 处理空字符串 (包括null NULL 等字符串)
     * <p>清除字符串中因为Null而产生的含有null,NULL等</>
     *
     * @param oldStr 待清清字符
     * @return 清除了null字样后返回
     */
    public static String processNull(String oldStr) {
        if (TextUtils.isEmpty(oldStr) || "null".equals(oldStr) || "NULL".equals(oldStr)) {
            oldStr = "";
        }
        return oldStr;
    }

    /**
     * 判断对象处理为空
     *  <P>也返回true, 注意如果是字符串(String)未含字符.
     *  <P>返回true, 集合(list,set,map)或数组（[]）中没有元素.
     * @param obj 对像，
     * @return true 对象为空（注意如果是字符串(String)未含字符也返回true)
     */
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        } else if (obj instanceof String) {
            String string = (String) obj;
            if (string.length() <= 0) {
                return true;
            } else if ("".equals(string)) {
                return true;
            } else if ("".equals(string.trim())) {
                return true;
            }
        } else if (obj instanceof List) {
            List list = (List) obj;
            if (list.size() <= 0) {
                return true;
            } else if (list.isEmpty()) {
                return true;
            }
        } else if (obj instanceof Set) {
            Set list = (Set) obj;
            if (list.size() <= 0) {
                return true;
            } else if (list.isEmpty()) {
                return true;
            }
        } else if (obj instanceof Map) {
            Map map = (Map) obj;
            if (map.size() <= 0) {
                return true;
            } else if (map.isEmpty()) {
                return true;
            }
        } else if (obj instanceof Object[]) {
            Object[] objs = (Object[]) obj;
            if (objs.length <= 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 反转字符串
     *
     * @param str        源字符串
     * @param splitRegex 分隔符
     * @return
     */
    public static String reverseString(String str, String splitRegex) {
        if (str == null || str.trim().length() == 0) {
            return str;
        }
        if (splitRegex == null) {
            char[] chs = str.toCharArray();
            char[] nch = new char[chs.length];
            for (int i = 0; i < chs.length; i++) {
                nch[i] = chs[chs.length - 1 - i];
            }
            return new String(nch);
        } else {
            String[] arr = str.split(splitRegex.replace(".", "\\."), -1);
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[arr.length - 1 - i]).append(splitRegex);
            }
            if (sb.length() > str.length()) {
                sb.deleteCharAt(sb.length() - 1);
            }
            return new String(sb);
        }
    }

    /**
     * 得到一个字符串的长度,显示的长度,一个汉字或日韩文长度为2,英文字符长度为1
     *
     * @param s 需要得到长度的字符串
     * @return int 得到的字符串长度
     */
    public static int length(String s) {
        if (s == null) {
            return 0;
        }
        char[] c = s.toCharArray();
        int len = 0;
        int k = 0x80;
        for (int i = 0; i < c.length; i++) {
            len++;
            if (c[i] / k != 0) {
                len++;
            }
        }
        return len;
    }
}
